package com.cc.alltype;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;

public class ListUtils<T> {
    /**
     * 对象类型集合判断空逻辑：
     * 1. NULL、size = 0都认为是空，返回 true
     * 2. List 中所有元素都是 NULL 则认为 List 是空，返回 true
     * 3. List 中有一个元素不为空则返回 false
     * @param list
     * @return
     */
    public boolean isEmpty(List<T> list){
        if(list == null) return true;
        if(list.size() == 0) return true;
        for (T t : list) {
            if(t != null) return false;
        }
        return true;
    }

    /**
     * 在对象集合中检测指定名称的属性，存在重复数据则保留第一个，移除之后的所有重复元素
     * 支持字符串类型、整型类型的属性。没有返回值，直接加工第一个传入参数
     * @param list 对象集合
     * @param fieldName 对象属性名称，要求有该属性对应的小驼峰形式的 get 方法
     */
    public void removeDuplicateAtOneAtrriInObjList(List<T> list, String fieldName){
        if(list == null || list.size() == 0) return;

        T t = list.get(0);
        Class<?> clazz = t.getClass();
        boolean b = ReflectUtils.hasField(clazz, fieldName);
        if(!b) return;// 属性不存在则返回原始数据

        String methodName = "get" + StringUtils.toUpperCaseFirstChar(fieldName);
        b = ReflectUtils.hasMethod(clazz, methodName);
        if(!b) return;// 方法不存在则返回原始数据

        Method method = null;
        try {
            method = clazz.getDeclaredMethod(methodName);
        } catch (NoSuchMethodException e) {
            return;
        }
        if(method == null) return;

        Set<Object> cachedSet = new HashSet<>();
        Iterator<T> it = list.iterator();
        while (it.hasNext()) {
            T obj = it.next();
            if(obj == null) continue;
            System.out.println("当前元素：" + obj.toString());
            try {
                Object objString = method.invoke(obj);
                //String currentString = (String)objString;
                boolean contains = cachedSet.contains(objString);
                if(contains) {
                    System.out.println("键" + objString + "存在，即将移除");
                    it.remove();
                } else {
                    System.out.println("键" + objString + "不存在，即将缓存起来");
                    cachedSet.add(objString);
                }
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }
        }
    }



    public static void main(String[] args) {
        class Test{
            public String sid;
            public Integer qty;

            public String getSid() {
                return sid;
            }

            public void setSid(String sid) {
                this.sid = sid;
            }

            public Integer getQty() {
                return qty;
            }

            public void setQty(Integer qty) {
                this.qty = qty;
            }

            @Override
            public String toString() {
                return "Test{" +
                        "sid='" + sid + '\'' +
                        ", qty=" + qty +
                        '}';
            }
        }

        Test t1 = new Test();
        t1.sid = "张三";t1.qty = 11;
        Test t2 = new Test();
        t2.sid = "李四";t2.qty = 12;
        Test t3 = new Test();
        t3.sid = "王五";t3.qty = 11;
        ArrayList<Test> tests = new ArrayList<>();
        tests.add(t1);tests.add(t2);tests.add(t3);

        ListUtils listUtils = new ListUtils();
        listUtils.removeDuplicateAtOneAtrriInObjList(tests,"qty");
        System.out.println(tests);
    }
}
